home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / plan / src / cycmenu.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  19KB  |  576 lines
  1. /*
  2.  * Create and destroy the recycle popup. Recycling an entry means to specify
  3.  * days on which it recurs; whenever its trigger time has passed, it it
  4.  * changed to the next trigger date (see recycle()). The popup is installed
  5.  * when the Recycle icon (looks like two round arrows) is pressed.
  6.  *
  7.  *    destroy_recycle_popup()
  8.  *    create_recycle_popup()
  9.  */
  10.  
  11. #include <stdio.h>
  12. #include <time.h>
  13. #include <Xm/Xm.h>
  14. #include <Xm/DialogS.h>
  15. #include <Xm/Form.h>
  16. #include <Xm/Frame.h>
  17. #include <Xm/RowColumn.h>
  18. #include <Xm/LabelP.h>
  19. #include <Xm/LabelG.h>
  20. #include <Xm/PushBP.h>
  21. #include <Xm/PushBG.h>
  22. #include <Xm/ToggleB.h>
  23. #include <Xm/Text.h>
  24. #include <Xm/Protocols.h>
  25. #include "cal.h"
  26.  
  27. static void        done_callback(), wkday_callback(), day_callback(),
  28.             nth_callback(), every_callback(), every_text_callback(),
  29.             yearly_callback(), last_callback(),last_text_callback();
  30. extern time_t        parse_datestring();
  31. extern char        *mkdatestring();
  32. extern void        help_callback();
  33.  
  34. extern Display        *display;    /* everybody uses the same server */
  35. extern struct edit    edit;        /* info about entry being edited */
  36. extern struct config    config;        /* global configuration data */
  37. extern Pixel        color[NCOLS];    /* colors: COL_* */
  38. extern struct list    *mainlist;    /* list of all schedule entries */
  39. extern char        *weekday_name[];/* "Mon", "Tue", ... */
  40.  
  41. static BOOL        have_shell;    /* message popup exists if TRUE */
  42. static Widget        shell;        /* popup menu shell */
  43. static Widget        nth_widget[7];    /* any, 1st..5th, last toggle buttons*/
  44. static Widget        last;        /* last-on date text */
  45. static Widget        last_toggle;    /* last-on date toggle button */
  46. static Widget        every;        /* every n days text */
  47. static Widget        every_toggle;    /* every n days toggle button */
  48. static Widget        yearly_toggle;    /* every year togg÷e button */
  49.  
  50.  
  51. /*
  52.  * destroy a popup. Remove it from the screen, and destroy its widgets.
  53.  * It's too much trouble to keep them for next time.
  54.  */
  55.  
  56. destroy_recycle_popup()
  57. {
  58.     char            *string;    /* contents of text widget */
  59.  
  60.     if (have_shell && edit.editing) {
  61.         if (edit.entry.rep_every) {
  62.             string = XmTextGetString(every);
  63.             edit.entry.rep_every = atoi(string) * 86400;
  64.             if (edit.entry.rep_every < 0)
  65.                 edit.entry.rep_every = 0;
  66.             XtFree(string);
  67.         }
  68.         if (edit.entry.rep_last) {
  69.             string = XmTextGetString(last);
  70.             edit.entry.rep_last =
  71.                 parse_datestring(string, edit.entry.time);
  72.             XtFree(string);
  73.         }
  74.         edit.changed = TRUE;
  75.         edit.entry.suspended = FALSE;
  76.         print_pixmap(edit.menu->entry[edit.y][SC_RECYCLE],
  77.                 edit.entry.rep_yearly || edit.entry.rep_days ||
  78.                 edit.entry.rep_every || edit.entry.rep_weekdays
  79.                             ? PIC_RECYCLE : -1);
  80.     }
  81.     if (have_shell) {
  82.         XtPopdown(shell);
  83.         XTDESTROYWIDGET(shell);
  84.         have_shell = FALSE;
  85.         confirm_new_entry();
  86.     }
  87. }
  88.  
  89.  
  90. /*
  91.  * create a recycle popup as a separate application shell. The popup is
  92.  * initialized with data from edit.entry.
  93.  */
  94.  
  95. static char *nth_name[] = { "every...", "first...", "second...", "third...",
  96.                 "fourth...", "fifth...", "last..." };
  97.  
  98. create_recycle_popup()
  99. {
  100.     Widget            frame, frame2, form, form2, rowcol, w;
  101.     int            day;        /* weekdays and month days */
  102.     char            buf[10];    /* month day names */
  103.     register struct entry    *ep = &edit.entry;
  104.     Arg            args[20];
  105.     int            n;
  106.     Atom            closewindow;
  107.  
  108.     destroy_recycle_popup();
  109.  
  110.     n = 0;
  111.     XtSetArg(args[n], XmNdeleteResponse,    XmDO_NOTHING);        n++;
  112.     XtSetArg(args[n], XmNiconic,        False);            n++;
  113.     shell = XtAppCreateShell("Schedule Recycler", "plan",
  114.             applicationShellWidgetClass, display, args, n);
  115. #    ifdef EDITRES
  116.     XtAddEventHandler(shell, (EventMask)0, TRUE, 
  117.              _XEditResCheckMessages, NULL);
  118. #    endif
  119.     set_icon(shell, 1);
  120.     form = XtCreateManagedWidget("cycform1", xmFormWidgetClass,
  121.             shell, NULL, 0);
  122.     XtAddCallback(form, XmNhelpCallback, help_callback, (XtPointer)"cyc");
  123.  
  124.                             /*-- buttons --*/
  125.     n = 0;
  126.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  127.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  128.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  129.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  130.     XtSetArg(args[n], XmNleftOffset,    32);            n++;
  131.     XtSetArg(args[n], XmNwidth,        80);            n++;
  132.     w = XtCreateManagedWidget("Done", xmPushButtonWidgetClass,
  133.             form, args, n);
  134.     XtAddCallback(w, XmNactivateCallback, done_callback, (XtPointer)0);
  135.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)
  136.                                 "cyc_done");
  137.  
  138.     n = 0;
  139.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  140.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  141.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_WIDGET);    n++;
  142.     XtSetArg(args[n], XmNrightWidget,    w);            n++;
  143.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  144.     XtSetArg(args[n], XmNwidth,        80);            n++;
  145.     w = XtCreateManagedWidget("Help", xmPushButtonWidgetClass,
  146.             form, args, n);
  147.     XtAddCallback(w, XmNactivateCallback, help_callback, (XtPointer)"cyc");
  148.     XtAddCallback(w, XmNhelpCallback,     help_callback, (XtPointer)"cyc");
  149.  
  150.                             /*-- last on --*/
  151.     n = 0;
  152.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  153.     XtSetArg(args[n], XmNbottomWidget,    w);            n++;
  154.     XtSetArg(args[n], XmNbottomOffset,    20);            n++;
  155.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  156.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  157.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  158.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  159.     XtSetArg(args[n], XmNshadowType,    XmSHADOW_ETCHED_IN);    n++;
  160.     frame = XtCreateManagedWidget("", xmFrameWidgetClass,
  161.             form, args, n);
  162.     form2 = XtCreateManagedWidget("cycform2", xmFormWidgetClass,
  163.             frame, NULL, 0);
  164.     XtAddCallback(form2, XmNhelpCallback,
  165.                     help_callback, (XtPointer)"cyc_last");
  166.  
  167.     n = 0;
  168.     XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  169.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  170.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  171.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  172.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  173.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  174.     XtSetArg(args[n], XmNset,        ep->rep_last != 0);    n++;
  175.     last_toggle = XtCreateManagedWidget("Stop repeating on",
  176.             xmToggleButtonWidgetClass,
  177.             form2, args, n);
  178.     XtAddCallback(last_toggle, XmNvalueChangedCallback,
  179.                         last_callback, (XtPointer)0);
  180.  
  181.     n = 0;
  182.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  183.     XtSetArg(args[n], XmNtopOffset,        4);            n++;
  184.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  185.     XtSetArg(args[n], XmNbottomOffset,    4);            n++;
  186.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  187.     XtSetArg(args[n], XmNleftWidget,    last_toggle);        n++;
  188.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  189.     XtSetArg(args[n], XmNwidth,        140);            n++;
  190.     XtSetArg(args[n], XmNrecomputeSize,    False);            n++;
  191.     XtSetArg(args[n], XmNpendingDelete,    True);            n++;
  192.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  193.     XtSetArg(args[n], XmNbackground,    color[COL_TEXTBACK]);    n++;
  194.     last = XtCreateManagedWidget("", xmTextWidgetClass,
  195.             form2, args, n);
  196.     XtAddCallback(last, XmNactivateCallback,
  197.                     last_text_callback, (XtPointer)NULL);
  198.  
  199.                             /*-- repeat every --*/
  200.     n = 0;
  201.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  202.     XtSetArg(args[n], XmNbottomWidget,    frame);            n++;
  203.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  204.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  205.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  206.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  207.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  208.     XtSetArg(args[n], XmNshadowType,    XmSHADOW_ETCHED_IN);    n++;
  209.     frame = XtCreateManagedWidget("", xmFrameWidgetClass,
  210.             form, args, n);
  211.     form2 = XtCreateManagedWidget("cycform3", xmFormWidgetClass,
  212.             frame, NULL, 0);
  213.     XtAddCallback(form2, XmNhelpCallback,
  214.                     help_callback, (XtPointer)"cyc_every");
  215.  
  216.     n = 0;
  217.     XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  218.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  219.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  220.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  221.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  222.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  223.     XtSetArg(args[n], XmNset,        ep->rep_every != 0);    n++;
  224.     every_toggle = XtCreateManagedWidget("Repeat every",
  225.             xmToggleButtonWidgetClass,
  226.             form2, args, n);
  227.     XtAddCallback(every_toggle, XmNvalueChangedCallback,
  228.                         every_callback, (XtPointer)0);
  229.  
  230.     n = 0;
  231.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  232.     XtSetArg(args[n], XmNtopOffset,        4);            n++;
  233.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  234.     XtSetArg(args[n], XmNbottomOffset,    4);            n++;
  235.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  236.     XtSetArg(args[n], XmNleftWidget,    every_toggle);        n++;
  237.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  238.     XtSetArg(args[n], XmNwidth,        60);            n++;
  239.     XtSetArg(args[n], XmNrecomputeSize,    False);            n++;
  240.     XtSetArg(args[n], XmNpendingDelete,    True);            n++;
  241.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  242.     XtSetArg(args[n], XmNbackground,    color[COL_TEXTBACK]);    n++;
  243.     every = XtCreateManagedWidget("", xmTextWidgetClass,
  244.             form2, args, n);
  245.     XtAddCallback(every, XmNactivateCallback,
  246.                     every_text_callback, (XtPointer)NULL);
  247.  
  248.     n = 0;
  249.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  250.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  251.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  252.     XtSetArg(args[n], XmNleftWidget,    every);            n++;
  253.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  254.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  255.     w = XtCreateManagedWidget("days", xmLabelWidgetClass,
  256.             form2, args, n);
  257.  
  258.                             /*-- yearly --*/
  259.     n = 0;
  260.     XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  261.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  262.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  263.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  264.     XtSetArg(args[n], XmNleftWidget,    w);            n++;
  265.     XtSetArg(args[n], XmNleftOffset,    40);            n++;
  266.     XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  267.     XtSetArg(args[n], XmNset,        ep->rep_yearly);    n++;
  268.     yearly_toggle = XtCreateManagedWidget("Repeat every year",
  269.             xmToggleButtonWidgetClass,
  270.             form2, args, n);
  271.     XtAddCallback(yearly_toggle, XmNvalueChangedCallback,
  272.                 yearly_callback, (XtPointer)0);
  273.     XtAddCallback(yearly_toggle, XmNhelpCallback,
  274.                 help_callback, (XtPointer)"cyc_yearly");
  275.  
  276.                             /*-- weekdays --*/
  277.     n = 0;
  278.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  279.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  280.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  281.     XtSetArg(args[n], XmNbottomWidget,    frame);            n++;
  282.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  283.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  284.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  285.     XtSetArg(args[n], XmNshadowType,    XmSHADOW_ETCHED_IN);    n++;
  286.     frame2 = XtCreateManagedWidget("", xmFrameWidgetClass,
  287.             form, args, n);
  288.     form2 = XtCreateManagedWidget("cycform4", xmFormWidgetClass,
  289.             frame2, NULL, 0);
  290.     XtAddCallback(form2, XmNhelpCallback,
  291.                 help_callback, (XtPointer)"cyc_weekdays");
  292.  
  293.     n = 0;
  294.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  295.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  296.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  297.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  298.     w = XtCreateManagedWidget("Repeat on", xmLabelWidgetClass,
  299.             form2, args, n);
  300.     n = 0;
  301.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  302.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  303.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  304.     XtSetArg(args[n], XmNleftWidget,    w);            n++;
  305.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  306.     XtSetArg(args[n], XmNspacing,        4);            n++;
  307.     rowcol = XtCreateManagedWidget("", xmRowColumnWidgetClass,
  308.             form2, args, n);
  309.     for (day=0; day < 7; day++) {
  310.        BOOL on = day==0 ? !(ep->rep_weekdays & 0x3f00)
  311.                 :  (ep->rep_weekdays & 0x0080 << day) != 0;
  312.        n = 0;
  313.        XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  314.        XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  315.        XtSetArg(args[n], XmNset,        on);            n++;
  316.        nth_widget[day] = XtCreateManagedWidget(nth_name[day],
  317.               xmToggleButtonWidgetClass,
  318.             rowcol, args, n);
  319.        XtAddCallback(nth_widget[day], XmNvalueChangedCallback,
  320.                          nth_callback, (XtPointer)day);
  321.     }
  322.     n = 0;
  323.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  324.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  325.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  326.     XtSetArg(args[n], XmNleftWidget,    rowcol);        n++;
  327.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  328.     XtSetArg(args[n], XmNspacing,        4);            n++;
  329.     rowcol = XtCreateManagedWidget("", xmRowColumnWidgetClass,
  330.             form2, args, n);
  331.     for (day=0; day < 7; day++) {
  332.        int d = config.sunday_first ? day : (day+1)%7;
  333.        BOOL on = (ep->rep_weekdays & (1<<d)) != 0;
  334.        n = 0;
  335.        XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  336.        XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  337.        XtSetArg(args[n], XmNset,        on);            n++;
  338.        w = XtCreateManagedWidget(weekday_name[(d+6)%7],
  339.               xmToggleButtonWidgetClass,
  340.             rowcol, args, n);
  341.        XtAddCallback(w, XmNvalueChangedCallback,
  342.                          wkday_callback, (XtPointer)d);
  343.     }
  344.  
  345.                             /*-- month days --*/
  346.     n = 0;
  347.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  348.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  349.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_WIDGET);    n++;
  350.     XtSetArg(args[n], XmNbottomWidget,    frame);            n++;
  351.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  352.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  353.     XtSetArg(args[n], XmNleftWidget,    frame2);        n++;
  354.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  355.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  356.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  357.     XtSetArg(args[n], XmNshadowType,    XmSHADOW_ETCHED_IN);    n++;
  358.     frame2 = XtCreateManagedWidget("", xmFrameWidgetClass,
  359.             form, args, n);
  360.     form2 = XtCreateManagedWidget("cycform5", xmFormWidgetClass,
  361.             frame2, NULL, 0);
  362.     XtAddCallback(form2, XmNhelpCallback,
  363.                     help_callback, (XtPointer)"cyc_days");
  364.  
  365.     n = 0;
  366.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  367.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  368.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  369.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  370.     w = XtCreateManagedWidget("Repeat on the", xmLabelWidgetClass,
  371.             form2, args, n);
  372.     n = 0;
  373.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);        n++;
  374.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  375.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  376.     XtSetArg(args[n], XmNleftWidget,    w);            n++;
  377.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  378.     XtSetArg(args[n], XmNpacking,        XmPACK_COLUMN);        n++;
  379.     XtSetArg(args[n], XmNnumColumns,    4);            n++;
  380.     rowcol = XtCreateManagedWidget("", xmRowColumnWidgetClass,
  381.             form2, args, n);
  382.     for (day=1; day <= 32; day++) {
  383.        BOOL on = (ep->rep_days & (1<<(day&31))) != 0;
  384.        if (day == 32)
  385.         strcpy(buf, "Last");
  386.        else
  387.         sprintf(buf, "%d%s", day, (day%10)==1 && day!=11 ? "st" :
  388.                       (day%10)==2 && day!=12 ? "nd" :
  389.                       (day%10)==3 && day!=13 ? "rd" :
  390.                                     "th");
  391.        n = 0;
  392.        XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);    n++;
  393.        XtSetArg(args[n], XmNhighlightThickness,0);            n++;
  394.        XtSetArg(args[n], XmNset,        on);            n++;
  395.        w = XtCreateManagedWidget(buf, xmToggleButtonWidgetClass,
  396.             rowcol, args, n);
  397.        XtAddCallback(w, XmNvalueChangedCallback,
  398.                            day_callback, (XtPointer)day);
  399.     }
  400.  
  401.     XtPopup(shell, XtGrabNone);
  402.     closewindow = XmInternAtom(display, "WM_DELETE_WINDOW", False);
  403.     XmAddWMProtocolCallback(shell, closewindow,
  404.                     done_callback, (XtPointer)shell);
  405.  
  406.     if (ep->rep_last) {
  407.         char *space, *text = mkdatestring(ep->rep_last);
  408.         if ((space = strchr(text, ' ')))
  409.             text = space+1;
  410.         print_text_button(last, text);
  411.     }
  412.     if (ep->rep_every)
  413.         print_text_button(every, "%d", ep->rep_every/86400);
  414.     have_shell = TRUE;
  415. }
  416.  
  417.  
  418. /*-------------------------------------------------- callbacks --------------*/
  419. /*
  420.  * All of these routines are direct X callbacks.
  421.  */
  422.  
  423. /*ARGSUSED*/
  424. static void done_callback(widget, item, data)
  425.     Widget                widget;
  426.     int                item;
  427.     XmToggleButtonCallbackStruct    *data;
  428. {
  429.     destroy_recycle_popup();
  430. }
  431.  
  432.  
  433. /*ARGSUSED*/
  434. static void wkday_callback(widget, item, data)
  435.     Widget                widget;
  436.     int                item;
  437.     XmToggleButtonCallbackStruct    *data;
  438. {
  439.     if (data->set)
  440.         edit.entry.rep_weekdays |= 1 << item;
  441.     else
  442.         edit.entry.rep_weekdays &= ~(1 << item);
  443.     edit.changed = TRUE;
  444.     sensitize_edit_buttons();
  445. }
  446.  
  447.  
  448. /*ARGSUSED*/
  449. static void nth_callback(widget, item, data)
  450.     Widget                widget;
  451.     int                item;
  452.     XmToggleButtonCallbackStruct    *data;
  453. {
  454.     register struct entry        *ep = &edit.entry;
  455.     int                i;
  456.     Arg                args;
  457.  
  458.     if (item)
  459.         if (data->set)
  460.             ep->rep_weekdays |= 0x0080 << item;
  461.         else
  462.             ep->rep_weekdays &= ~(0x0080 << item);
  463.     else
  464.             ep->rep_weekdays &= ~0x3f00;
  465.     for (i=0; i < 7; i++) {
  466.         XtSetArg(args, XmNset, i ?  (ep->rep_weekdays & 0x0080<<i) != 0
  467.                      : !(ep->rep_weekdays & 0x3f00));
  468.         XtSetValues(nth_widget[i], &args, 1);
  469.     }
  470.     edit.changed = TRUE;
  471.     sensitize_edit_buttons();
  472. }
  473.  
  474.  
  475. /*ARGSUSED*/
  476. static void day_callback(widget, item, data)
  477.     Widget                widget;
  478.     int                item;
  479.     XmToggleButtonCallbackStruct    *data;
  480. {
  481.     if (data->set)
  482.         edit.entry.rep_days |= 1 << (item&31);
  483.     else
  484.         edit.entry.rep_days &= ~(1 << (item&31));
  485.     edit.changed = TRUE;
  486.     sensitize_edit_buttons();
  487. }
  488.  
  489.  
  490. /*ARGSUSED*/
  491. static void every_callback(widget, item, data)
  492.     Widget                widget;
  493.     int                item;
  494.     XmToggleButtonCallbackStruct    *data;
  495. {
  496.     if (data->set) {
  497.         XmProcessTraversal(every, XmTRAVERSE_CURRENT);
  498.         edit.entry.rep_every = 86400;
  499.         print_text_button(every, "1");
  500.     } else {
  501.         edit.entry.rep_every = 0;
  502.         print_text_button(every, "");
  503.     }
  504.     edit.changed = TRUE;
  505.     sensitize_edit_buttons();
  506. }
  507.  
  508.  
  509. /*ARGSUSED*/
  510. static void every_text_callback(widget, item, data)
  511.     Widget                widget;
  512.     int                item;
  513.     XmToggleButtonCallbackStruct    *data;
  514. {
  515.     char                *text = XmTextGetString(widget);
  516.     Arg                args;
  517.  
  518.     edit.entry.rep_every = atoi(text) * 86400;
  519.     if (edit.entry.rep_every < 0)
  520.         edit.entry.rep_every = 0;
  521.     XtSetArg(args, XmNset, edit.entry.rep_every > 0);
  522.     XtSetValues(every_toggle, &args, 1);
  523.     XtFree(text);
  524. }
  525.  
  526.  
  527. /*ARGSUSED*/
  528. static void yearly_callback(widget, item, data)
  529.     Widget                widget;
  530.     int                item;
  531.     XmToggleButtonCallbackStruct    *data;
  532. {
  533.     edit.entry.rep_yearly = data->set;
  534.     edit.changed = TRUE;
  535.     sensitize_edit_buttons();
  536. }
  537.  
  538.  
  539. /*ARGSUSED*/
  540. static void last_callback(widget, item, data)
  541.     Widget                widget;
  542.     int                item;
  543.     XmToggleButtonCallbackStruct    *data;
  544. {
  545.     if (data->set) {
  546.         char *p, date[40];
  547.         XmProcessTraversal(last, XmTRAVERSE_CURRENT);
  548.         edit.entry.rep_last = edit.entry.time -
  549.                       edit.entry.time % 86400 + 86400;
  550.         strcpy(date, mkdatestring(edit.entry.rep_last));
  551.         p = strchr(date, ' ');
  552.         print_text_button(last, p ? p+1 : date);
  553.     } else {
  554.         edit.entry.rep_last = 0;
  555.         print_text_button(last, "");
  556.     }
  557.     edit.changed = TRUE;
  558.     sensitize_edit_buttons();
  559. }
  560.  
  561.  
  562. /*ARGSUSED*/
  563. static void last_text_callback(widget, item, data)
  564.     Widget                widget;
  565.     int                item;
  566.     XmToggleButtonCallbackStruct    *data;
  567. {
  568.     char                *text = XmTextGetString(widget);
  569.     Arg                args;
  570.  
  571.     edit.entry.rep_last = parse_datestring(text, edit.entry.time);
  572.     XtSetArg(args, XmNset, edit.entry.rep_last > 0);
  573.     XtSetValues(last_toggle, &args, 1);
  574.     XtFree(text);
  575. }
  576.